src/renderpng.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335

#include "renderpng.h"
#include "position.h"
#include "map.h"
#include "cell.h"

#include "image.h"
#include "palette.h"
#include "font.h"

#include <math.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

RenderPng::RenderPng( Map &rMap ) :
    rMap( rMap )
{
}

RenderPng::~RenderPng()
{
}

void RenderPng::render()
{
    int iDims = rMap.getDims();
    int iSize = 1;
    if( iDims > 2 )
        iSize = (int)ceil(sqrt((rMap.getDims()-2)*2));

    int iCellSize = 11;
    int iCellMid = iCellSize/2;
    int iBufWidth = ((iSize+1)*rMap.getSize( 0 )+1)*iCellSize;
    int iBufHeight = ((iSize+1)*rMap.getSize( 1 )+1)*iCellSize+12;
    int ox = 0;
    int oy = 12;
    Image im( iBufWidth, iBufHeight );
    Font fnt("ter-u12n.bdf");
    im.clear( 1 );
    Palette pal;
    pal.addColor( 0, 0, 0 );
    pal.addColor( 255, 255, 255 );

    Position p( iDims );
    for(;;)
    {
        int x = p[0]*(iSize+1);
        int y = p[1]*(iSize+1);
        int iWalls = rMap[p].iWalls;
         
        for( int iRow = 0; iRow < iSize+2; iRow++ )
        {
            for( int iCol = 0; iCol < iSize+2; iCol++ )
            {
                if( (iRow == 0 || iRow == iSize+1) &&
                    (iCol == 0 || iCol == iSize+1) )
                {
                    im.set(
                        ox+(x+iCol)*iCellSize+iCellMid,
                        oy+(y+iRow)*iCellSize+iCellMid,
                        0
                        );
                    if( iRow == 0 && iCol == 0 )
                    {
                        if( (iWalls&(1<<2)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i+iCellMid+1,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<0)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i+iCellMid+1,
                                    0
                                    );
                        }
                    }
                    else if( iRow == 0 && iCol == iSize+1 )
                    {
                        if( (iWalls&(1<<2)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<1)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i+iCellMid+1,
                                    0
                                    );
                        }
                    }
                    else if( iRow == iSize+1 && iCol == 0 )
                    {
                        if( (iWalls&(1<<3)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i+iCellMid+1,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<0)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i,
                                    0
                                    );
                        }
                    }
                    else if( iRow == iSize+1 && iCol == iSize+1 )
                    {
                        if( (iWalls&(1<<3)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<1)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i,
                                    0
                                    );
                        }
                    }
                }
                else if( iRow == 0 && (iWalls&(1<<2)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+i,
                            oy+(y+iRow)*iCellSize+iCellMid,
                            0
                            );
                    }
                }
                else if( iRow == iSize+1 && (iWalls&(1<<3)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+i,
                            oy+(y+iRow)*iCellSize+iCellMid,
                            0
                            );
                    }
                }
                else if( iCol == 0 && (iWalls&(1<<0)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+iCellMid,
                            oy+(y+iRow)*iCellSize+i,
                            0
                            );
                    }
                }
                else if( iCol == iSize+1 && (iWalls&(1<<1)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+iCellMid,
                            oy+(y+iRow)*iCellSize+i,
                            0
                            );
                    }
                }
            }
        }

        for( int j = 2; j < iDims; j++ )
        {
            for( int side = 0; side < 2; side++ )
            {
                int d = j*2+side;
                if( iWalls&(1<<d) )
                {
                    int iSubX = (x+1+((d-4)%iSize))*iCellSize;
                    int iSubY = (y+1+((d-4)/iSize))*iCellSize;

                    switch( d )
                    {
                        case 4:
                            im.set( ox+iSubX+iCellMid, oy+iSubY+1, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+m, oy+iSubY+iCellMid-m+1, 0 );
                                im.set( ox+iSubX+iCellMid+m+1, oy+iSubY+m+2, 0 );
                            }
                            /*
                            im.set( iSubX+2, iSubY+1, 0 );
                            im.set( iSubX+1, iSubY+2, 0 );
                            im.set( iSubX+3, iSubY+2, 0 );
                            im.set( iSubX+0, iSubY+3, 0 );
                            im.set( iSubX+4, iSubY+3, 0 );
                            */
                            break;

                        case 5:
                            im.set( ox+iSubX+iCellMid, oy+iSubY+iCellSize-2, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+m, oy+iSubY+iCellMid+m-1, 0 );
                                im.set( ox+iSubX+iCellMid+m+1, oy+iSubY+iCellSize-m-3, 0 );
                            }
                            /*
                            im.set( iSubX+2, iSubY+3, 0 );
                            im.set( iSubX+1, iSubY+2, 0 );
                            im.set( iSubX+3, iSubY+2, 0 );
                            im.set( iSubX+0, iSubY+1, 0 );
                            im.set( iSubX+4, iSubY+1, 0 );
                            */
                            break;

                        case 6:
                            im.set( ox+iSubX+1, oy+iSubY+iCellMid, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+iCellMid-m+1, oy+iSubY+m, 0 );
                                im.set( ox+iSubX+m+2, oy+iSubY+iCellMid+m+1, 0 );
                            }
                            /*
                            im.set( iSubX+1, iSubY+2, 0 );
                            im.set( iSubX+2, iSubY+1, 0 );
                            im.set( iSubX+2, iSubY+3, 0 );
                            im.set( iSubX+3, iSubY+0, 0 );
                            im.set( iSubX+3, iSubY+4, 0 );
                            */
                            break;

                        case 7:
                            im.set( ox+iSubX+iCellSize-2, oy+iSubY+iCellMid, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+iCellMid+m-1, oy+iSubY+m, 0 );
                                im.set( ox+iSubX+iCellSize-m-3, oy+iSubY+iCellMid+m+1, 0 );
                            }
                            /*
                            im.set( iSubX+3, iSubY+2, 0 );
                            im.set( iSubX+2, iSubY+1, 0 );
                            im.set( iSubX+2, iSubY+3, 0 );
                            im.set( iSubX+1, iSubY+0, 0 );
                            im.set( iSubX+1, iSubY+4, 0 );
                            */
                            break;
                    }
                }
            }
        }

        int iDim;
        char fname[1024];
        char title[1024];
        for( iDim = 0; iDim < iDims; iDim++ )
        {
            if( ++p[iDim] < rMap.getSize( iDim ) )
                break;
            p[iDim] = 0;
            if( iDim == 1 )
            {
                strcpy(fname, "floor");
                if( iDims > 2 )
                {
                    char buf[1024];
                    sprintf( buf, "-%d", rMap.getSize(2)-p[2] );
                    strcat( fname, buf );
                    sprintf( buf, "Floor: %d", rMap.getSize(2)-p[2] );
                    strcpy( title, buf );
                    for( int j = 3; j < iDims; j++ )
                    {
                        sprintf( buf, "-%d", rMap.getSize(j)-p[j] );
                        strcat( fname, buf );
                        sprintf( buf, ", %d", rMap.getSize(j)-p[j] );
                        strcat( title, buf );
                    }
                }
                else
                    title[0] = '\0';
                im.drawText( fnt, ox, oy-2, 0, title );
                strcat( fname, ".png");
                printf("Output: %s\n", fname );
   
                im.save( fname, pal );

                im.clear( 1 );
            }
        }
        if( iDim == iDims )
            break;
/*
        for( int j = 2; j < iDims; j++ )
        {
            for( int side = 0; side < 2; side++ )
            {
                int d = j*2+side;
                if( iWalls&(1<<d) )
                {
                    int iSubX = (d-4)%iSize;
                    int iSubY = (d-4)/iSize;
                    char &c = buf[x+1+iSubX+(y+1+iSubY)*iBufWidth];
                    c = cPassages[d];
                }
            }
        }
  */      
    }
//                printf(buf);

}